;;; GNU Guix --- Functional package management for GNU
;;;
;;; Copyright © 2022 konkrotte <konkrotte@posteo.net>
;;; Copyright © 2022 Raghav Gururajan <rg@raghavgururajan.name>
;;; Copyright © 2022 donotshake <donotshake:matrix.org>
;;; Copyright © 2022 Dhruvin Gandhi <contact@dhruvin.dev>
;;; Copyright © 2022 jgart <jgart@dismail.de>
;;; Copyright © 2022 (unmatched parenthesis <paren@disroot.org>
;;;
;;; This file is not part of GNU Guix.
;;;
;;; GNU Guix is free software; you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 3 of the License, or (at
;;; your option) any later version.
;;;
;;; GNU Guix is distributed in the hope that it will be useful, but
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.

(define-module (guixrus packages common go)
  #:use-module (guix build-system go)
  #:use-module (guix gexp)
  #:use-module (guix download)
  #:use-module (guix git-download)
  #:use-module ((guix licenses) #:prefix license:)
  #:use-module (guix packages)
  #:use-module (guix utils)
  #:use-module (gnu packages golang)
  #:use-module (gnu packages mail)
  #:use-module (gnu packages syncthing)
  #:use-module (gnu packages video)
  #:use-module (ice-9 match))

(define (guixrus-go-target target)
    ;; Parse the nix-system equivalent of the target and set the
    ;; target for compilation accordingly.
    (match (string-split (gnu-triplet->nix-system target) #\-)
      ((arch os)
       (list (match arch
               ("aarch64" "arm64")
               ("armhf" "arm")
               ("powerpc64le" "ppc64le")
               ("powerpc64" "ppc64")
               ("i686" "386")
               ("x86_64" "amd64")
               ("mips64el" "mips64le")
               (_ arch))
             (match os
               ((or "mingw32" "cygwin") "windows")
               (_ os))))))

(define-public go-github-com-rs-xid
  (package
    (name "go-github-com-rs-xid")
    (version "1.2.1")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/rs/xid")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "1vgw1dikqw273awcci6pzifs7shkl5ah4l88j1zjbnpgbiwzlx9j"))))
    (build-system go-build-system)
    (inputs (list go-golang-org-x-image))
    (arguments
     `(#:import-path "github.com/rs/xid"))
    (home-page "https://github.com/rs/xid")
    (synopsis "Globally unique id generator thought for the web")
    (description
"@code{go-github-com-rs-xid} is a globally unique id generator
library, ready to safely be used directly in your server code.")
    (license license:expat)))

(define-public go-github-com-jpillora-sizestr
  (let ((commit "e2ea2fa42fb952f895ab2029f26d3a73b0d56eb3")
        (revision "1"))
    (package
      (name "go-github-com-jpillora-sizestr")
      (version (git-version "20160129" revision commit))
      (source (origin
                (method git-fetch)
                (uri (git-reference
                      (url "github.com/jpillora/sizestr")
                      (commit commit)))
                (file-name (git-file-name name commit))
                (sha256
                 (base32
                  "12kg8s11fsicp2ff9wlb1zca3fndhbi2isppcgdc2frkn90ml205"))))
      (build-system go-build-system)
      (arguments
       `(#:import-path "github.com/jpillora/sizestr"))
      (home-page "github.com/jpillora/sizestr")
      (synopsis "Pretty print byte counts in Go")
      (description
"@code{go-github-com-jpillora-sizestr} provides a library to pretty
print byte counts in Go.")
      (license license:expat))))

(define-public go-github-com-konsorten-go-windows-terminal-sequences
  (package
    (name "go-github-com-konsorten-go-windows-terminal-sequences")
    (version "1.0.2")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/konsorten/go-windows-terminal-sequences")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "09mn209ika7ciy87xf2x31dq5fnqw39jidgaljvmqxwk7ff1hnx7"))))
    (build-system go-build-system)
    (arguments
     `(#:import-path "github.com/konsorten/go-windows-terminal-sequences"))
    (home-page "github.com/konsorten/go-windows-terminal-sequences/")
    (synopsis "Enable support for Windows Terminal Colors")
    (description
"@code{go-github-com-go-windows-terminal-sequences} is a globally unique id generator
library, ready to safely be used directly in your server code.")
    (license license:expat)))

(define-public go-github-com-gliderlabs-ssh
  (package
    (name "go-github-com-gliderlabs-ssh")
    (version "0.2.2")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/gliderlabs/ssh")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "1gzbyhs8i08jz2nm1460lv35wlmi415k285mpnrzhwm8qhsy0h0x"))))
    (build-system go-build-system)
    (inputs
      (list go-golang-org-x-crypto
            go-golang-org-x-sys
            go-github-com-anmitsu-go-shlex))
    (arguments
     `(#:import-path "github.com/gliderlabs/ssh"))
    (home-page "https://github.com/gliderlabs/ssh")
    (synopsis "Easy SSH servers in Golang")
    (description
"@code{go-github-com-gliderlabs-ssh} wraps the crypto/ssh package with
a higher-level API for building SSH servers.")
    (license license:bsd-3)))

(define-public go-github-com-oklog-run
  (package
    (name "go-github-com-oklog-run")
    (version "1.1.0")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/oklog/run")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "0r55p3kgdkgw55i33lqvvvl60mjp92mhd1170m980sw98z9150jk"))))
    (build-system go-build-system)
    (arguments
     `(#:import-path "github.com/oklog/run"))
    (home-page "https://github.com/oklog/run")
    (synopsis "Universal mechanism to manage goroutine lifecycles")
    (description
"@code{go-github-com-oklog-run} a universal mechanism to manage goroutine
lifecycles.")
    (license license:asl2.0)))

(define-public go-github-com-hashicorp-errwrap
  (package
    (name "go-github-com-hashicorp-errwrap")
    (version "1.0.0")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/hashicorp/errwrap")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "0slfb6w3b61xz04r32bi0a1bygc82rjzhqkxj2si2074wynqnr1c"))))
    (build-system go-build-system)
    (arguments
     `(#:import-path "github.com/hashicorp/errwrap"))
    (home-page "https://github.com/hashicorp/errwrap")
    (synopsis "Library for wrapping and querying errors")
    (description
"@code{go-github-com-hashicorp-errwrap} is a package that formalizes
the pattern of wrapping errors and checking if an error contains another
error.")
    (license license:asl2.0)))

(define-public go-github-com-anmitsu-go-shlex
  (package
    (name "go-github-com-anmitsu-go-shlex")
    (version "0.0.0-20200514113438-38f4b401e2be")
    (source
      (origin
        (method git-fetch)
        (uri (git-reference
               (url "https://github.com/anmitsu/go-shlex")
               (commit (go-version->git-ref version))))
        (file-name (git-file-name name version))
        (sha256
          (base32 "17iz68yzbnr7y4s493asbagbv79qq8hvl2pkxvm6bvdkgphj8w1g"))))
    (build-system go-build-system)
    (arguments '(#:import-path "github.com/anmitsu/go-shlex"))
    (home-page "https://github.com/anmitsu/go-shlex")
    (synopsis "Lexical analyzer like Unix shell for golang")
    (description
"@code{go-github-com-anmitsu-go-shlex} provides a simple lexical analysis like
the Unix shell.")
    (license license:expat)))

(define-public go-github-com-vividcortex-gohistogram
  (package
    (name "go-github-com-vividcortex-gohistogram")
    (version "1.0.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/VividCortex/gohistogram")
             (commit (string-append "v" version))))
       (file-name (git-file-name name version))
       (sha256
        (base32 "1ykpvrkri3mzc0z77kdva93ylh0bqg7jq3i024r3iv0i6bwx3rnf"))))
    (build-system go-build-system)
    (arguments '(#:import-path "github.com/VividCortex/gohistogram"))
    (home-page "https://github.com/VividCortex/gohistogram")
    (synopsis "Streaming approximate histograms in Go")
    (description
"@code{go-github-com-vividcortex-gohistogram} contains implementations
of weighted and exponential histograms.")
    (license license:expat)))

(define-public go-github-com-bradfitz-iter
  (package
    (name "go-github-com-bradfitz-iter")
    (version "0.0.0-20191230175014-e8f45d346db8")
    (source
      (origin
        (method git-fetch)
        (uri (git-reference
               (url "https://github.com/bradfitz/iter")
               (commit (go-version->git-ref version))))
        (file-name (git-file-name name version))
        (sha256
          (base32 "1qqy1fhmlrsfz6l1arsxmkpfj30s090j1a3ij0lap6h45pc1z509"))))
    (build-system go-build-system)
    (arguments '(#:import-path "github.com/bradfitz/iter"))
    (home-page "https://github.com/bradfitz/iter")
    (synopsis "Syntactically different way to iterate over integers")
    (description
"@code{go-github-com-bradfitz-iter} provides a syntactically different
way to iterate over integers.  That's it.")
    (license license:bsd-3)))

(define-public go-github-com-buger-goterm
  (package
    (name "go-github-com-buger-goterm")
    (version "0.0.0-20200322175922-2f3e71b85129")
    (source
      (origin
        (method git-fetch)
        (uri (git-reference
               (url "https://github.com/buger/goterm")
               (commit (go-version->git-ref version))))
        (file-name (git-file-name name version))
        (sha256
          (base32 "04hpshhw27n9i8mab8z61nb0ahrv9wyn7a39qm1a8nvsa97706lx"))))
    (build-system go-build-system)
    (arguments
     '(#:import-path "github.com/buger/goterm"
       #:tests? #f)) ;; FIXME: resolve tests failing
    (propagated-inputs `(("go-golang-org-x-sys" ,go-golang-org-x-sys)))
    (home-page "https://github.com/buger/goterm")
    (synopsis "Building blocks for advanced console UIs")
    (description
"@code{go-github-com-buger-goterm} provides basic building blocks for
advanced console UI")
    (license license:expat)))

(define-public go-github-com-hashicorp-go-multierror
  (package
    (name "go-github-com-hashicorp-go-multierror")
    (version "1.0.0")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/hashicorp/go-multierror")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "00nyn8llqzbfm8aflr9kwsvpzi4kv8v45c141v88xskxp5xf6z49"))))
    (build-system go-build-system)
    (arguments
     `(#:import-path "github.com/hashicorp/go-multierror"))
    (inputs
      (list go-github-com-hashicorp-errwrap))
    (home-page "https://github.com/hashicorp/go-multierror")
    (synopsis "Go library providing a list of error values as a single error")
    (description
"@code{go-github-com-hashicorp-go-multierror} is a package that provides
a mechanism for representing a list of error values as a single error.")
    (license license:mpl2.0)))

(define-public go-github-com-gosuri-uilive
  (package
    (name "go-github-com-gosuri-uilive")
    (version "0.0.4")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/gosuri/uilive")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "0pwxx0w4mv908dascnxkdjq865ks01niqy71imv4kllz0a84zkag"))))
    (build-system go-build-system)
    (arguments
     `(#:import-path "github.com/gosuri/uilive"))
    (home-page "https://github.com/gosuri/uilive/")
    (synopsis "Go library for updating terminal output in realtime")
    (description
"@code{go-github-com-gosuri-uilive} go library for updating terminal
output in realtime.  It provides a buffered io.Writer that is flushed
at a timed interval. @code{go-github-com-gosuri-uilive} powers
@code{go-github-com-gosuri-uiprogress}.")
    (license license:expat)))

(define-public go-github-com-gosuri-uiprogress
  (package
    (name "go-github-com-gosuri-uiprogress")
    (version "0.0.1")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/gosuri/uilive")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "1k28zbc14p1yqzhamp9rcagjdw6wsdb55m08nx758jwlr31az6jy"))))
    (build-system go-build-system)
    (arguments
     `(#:import-path "github.com/gosuri/uiprogress"))
    (inputs
      (list go-github-com-gosuri-uilive
            go-github-com-mattn-go-isatty))
    (home-page "https://github.com/gosuri/uilive/")
    (synopsis "Go library to render progress bars in terminal applications")
    (description
"@code{go-github-com-gosuri-uiprogress} is go library to render progress
bars in terminal applications.")
    (license license:expat)))

(define-public go-github-com-klauspost-pgzip
  (package
    (name "go-github-com-klauspost-pgzip")
    (version "1.2.5")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/klauspost/pgzip")
             (commit (string-append "v" version))))
       (file-name (git-file-name name version))
       (sha256
        (base32 "0m66jcsz27076qvi5qzagzlbyd1sdzh6kbf1njj0sswx86026rx3"))))
    (build-system go-build-system)
    (arguments '(#:import-path "github.com/klauspost/pgzip"))
    (inputs
     `(("go-github-com-klauspost-compress" ,go-github-com-klauspost-compress)))
    (home-page "https://github.com/klauspost/pgzip")
    (synopsis "Go parallel gzip (de)compression")
    (description
     "@code{go-github-com-klauspost-pgzip} implements reading and writing
of gzip format compressed files, as specified in
@url{https://rfc-editor.org/rfc/rfc1952.html,RFC 1952}.")
    (license license:expat)))

(define-public go-github-com-hooklift-assert
  (package
    (name "go-github-com-hooklift-assert")
    (version "0.1.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/hooklift/assert")
             (commit (string-append "v" version))))
       (file-name (git-file-name name version))
       (sha256
        (base32 "1lizg628wwh95n3dw5x17ihpx62i6szg7632nj2v4db15g7y5clb"))))
    (build-system go-build-system)
    (arguments '(#:import-path "github.com/hooklift/assert"))
    (home-page "https://github.com/hooklift/assert")
    (synopsis "Minimalist assertion library")
    (description synopsis)
    (license license:mpl2.0)))

(define-public go-github-com-dsnet-golib
  (package
    (name "go-github-com-dsnet-golib")
    (version "0.0.0-20171103203638-1ea166775780")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/dsnet/golib")
             (commit (go-version->git-ref version))))
       (file-name (git-file-name name version))
       (sha256
        (base32 "1pm5wkiyh8cilyrrw310ygyj3sdb2831aizym2cgs62aaa3iqrvc"))))
    (build-system go-build-system)
    (arguments '(#:import-path "github.com/dsnet/golib"))
    (home-page "https://github.com/dsnet/golib")
    (synopsis "Collection of helper libraries for Go")
    (description
     "@code{go-github-com-dsnet-golib} is a collection of mostly unrelated
helper libraries.")
    (license license:bsd-3)))

(define-public go-github-com-dsnet-compress
  (package
    (name "go-github-com-dsnet-compress")
    (version "0.0.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/dsnet/compress")
             (commit (string-append "v" version))))
       (file-name (git-file-name name version))
       (sha256
        (base32 "1wwjaymzb1xxq3ybch3nwn72xhi2s40cvz0cl986yad3w1xwzj91"))))
    (build-system go-build-system)
    (arguments '(#:import-path "github.com/dsnet/compress"))
    (propagated-inputs
     `(("go-github.com-ulikunitz-xz" ,go-github.com-ulikunitz-xz)
       ("go-github-com-klauspost-cpuid" ,go-github-com-klauspost-cpuid)
       ("go-github-com-klauspost-compress" ,go-github-com-klauspost-compress)
       ("go-github-com-dsnet-golib" ,go-github-com-dsnet-golib)))
    (home-page "https://github.com/dsnet/compress")
    (synopsis "Collection of compression libraries for Go")
    (description synopsis)
    (license license:bsd-3)))

(define-public go-github-com-c4milo-unpackit
  (package
    (name "go-github-com-c4milo-unpackit")
    (version "0.0.0-20170704181138-4ed373e9ef1c")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/c4milo/unpackit")
             (commit (go-version->git-ref version))))
       (file-name (git-file-name name version))
       (sha256
        (base32 "0va5sw1057lg6c3xs581ajwswrkkv8kg948rm9q3bf2ssdxcc83p"))))
    (build-system go-build-system)
    (arguments '(#:import-path "github.com/c4milo/unpackit"))
    (inputs
     `(("go-github.com-ulikunitz-xz" ,go-github.com-ulikunitz-xz)
       ("go-github-com-pkg-errors" ,go-github-com-pkg-errors)
       ("go-github-com-klauspost-pgzip" ,go-github-com-klauspost-pgzip)
       ("go-github-com-hooklift-assert" ,go-github-com-hooklift-assert)
       ("go-github-com-dsnet-compress" ,go-github-com-dsnet-compress)
       ("go-github-com-bradfitz-iter" ,go-github-com-bradfitz-iter)))
    (home-page "https://github.com/c4milo/unpackit")
    (synopsis "Natively decompress and unarchive tar files in Go")
    (description
"@code{go-github-com-c4milo-unpackit} allows you to easily unpack
*.tar.gz, *.tar.bzip2, *.tar.xz, *.zip and *.tar files.  CGO is not
involved nor hard dependencies of any type.")
    (license license:mpl2.0)))

(define-public go-github-com-eiannone-keyboard
  (package
    (name "go-github-com-eiannone-keyboard")
    (version "0.0.0-20190314115158-7169d0afeb4f")
    (source
      (origin
        (method git-fetch)
        (uri (git-reference
               (url "https://github.com/eiannone/keyboard")
               (commit (go-version->git-ref version))))
        (file-name (git-file-name name version))
        (sha256
          (base32 "0q4vrfia21c8yx2iaksspd16b3vxg7cc6ba6sjd3z9k8pply13p7"))))
    (build-system go-build-system)
    (arguments
     '(#:import-path "github.com/eiannone/keyboard"))
    (inputs
     `(("go-golang-org-x-sys" ,go-golang-org-x-sys)))
    (home-page "https://github.com/eiannone/keyboard")
    (synopsis "Library to listen for keystrokes from the keyboard")
    (description synopsis)
    (license license:expat)))

(define-public go-github-com-dchest-uniuri
  (package
    (name "go-github-com-dchest-uniuri")
    (version "0.0.0-20200228104902-7aecb25e1fe5")
    (source
      (origin
        (method git-fetch)
        (uri (git-reference
               (url "https://github.com/dchest/uniuri")
               (commit (go-version->git-ref version))))
        (file-name (git-file-name name version))
        (sha256
          (base32 "1rd9b8dwwrl1vw063qcdkfp8j4y90vq73czq39g24k2nbxdpb5bz"))))
    (build-system go-build-system)
    (arguments '(#:import-path "github.com/dchest/uniuri"))
    (home-page "https://github.com/dchest/uniuri")
    (synopsis "Generates random strings to identity unique objects")
    (description
"@code{go-github-com-dchest-uniuri} generates random strings good for
use in URIs to identify uniqueobjects.")
    (license license:cc0)))

(define-public go-github-com-nu7hatch-gouuid
  (package
    (name "go-github-com-nu7hatch-gouuid")
    (version "0.0.0-20131221200532-179d4d0c4d8d")
    (source
      (origin
        (method git-fetch)
        (uri (git-reference
               (url "https://github.com/nu7hatch/gouuid")
               (commit (go-version->git-ref version))))
        (file-name (git-file-name name version))
        (sha256
          (base32 "1isyfix5w1wm26y3a15ha3nnpsxqaxz5ngq06hnh6c6y0inl2fwj"))))
    (build-system go-build-system)
    (arguments
     '(#:import-path "github.com/nu7hatch/gouuid"
       #:tests? #f)) ;; FIXME: tests fail
    (home-page "https://github.com/nu7hatch/gouuid")
    (synopsis "Pure Go UUID implementation")
    (description
"@code{go-github-com-nu7hatch-gouuid} provides immutable UUID structs
and the functions NewV3, NewV4, NewV5 and Parse() for generating
versions 3, 4 and 5 UUIDs as specified in
@url{https://rfc-editor.org/rfc/rfc4122.html,RFC 4122}.")
    (license license:expat)))

;; (define-public go-github-com-shurcool-vfsgen
;;   (package
;;     (name "go-github-com-shurcool-vfsgen")
;;     (version "0.0.0-20200824052919-0d455de96546")
;;     (source
;;       (origin
;;         (method git-fetch)
;;         (uri (git-reference
;;                (url "https://github.com/shurcooL/vfsgen")
;;                (commit (go-version->git-ref version))))
;;         (file-name (git-file-name name version))
;;         (sha256
;;           (base32 "0md1vgaq95x1jmxpnsfv6s9xf3v8gqi7lcl7mkxpf6274rf1n2pk"))))
;;     (build-system go-build-system)
;;     (arguments '(#:import-path "github.com/shurcool/vfsgen"))
;;     (inputs
;;      `(("go-github-com-shurcool-httpfs" ,go-github-com-shurcool-httpfs)))
;;     (home-page "https://github.com/shurcool/vfsgen")
;;     (synopsis #f)
;;     (description
;; "@code{go-github-com-shurcool-vfsgen} takes an http.FileSystem (likely
;; at `go generate` time) and generates Go code that statically
;; implements the provided http.FileSystem.")
;;     (license license:expat)))

;; (define-public go-github-com-shurcool-httpfs
;;   (package
;;     (name "go-github-com-shurcool-httpfs")
;;     (version "0.0.0-20190707220628-8d4bc4ba7749")
;;     (source
;;       (origin
;;         (method git-fetch)
;;         (uri (git-reference
;;                (url "https://github.com/shurcooL/httpfs")
;;                (commit (go-version->git-ref version))))
;;         (file-name (git-file-name name version))
;;         (sha256
;;           (base32 "0qjkbjnp86kjr7r0xjwp39blnk1ggkzy6zm3xphr5dpin4jkgfa1"))))
;;     (build-system go-build-system)
;;     (arguments '(#:import-path "github.com/shurcool/httpfs/vfspath"))
;;     (home-page "https://github.com/shurcool/httpfs")
;;     (synopsis "Collection of Go packages for working with the http.FileSystem interface.")
;;     (description
;; "@code{go-github-com-shurcool-httpfs} is a collection of Go packages
;; for working with the @url{https://godoc.org/net/http#FileSystem,(code
;; http.FileSystem)} interface.")
;;     (license license:expat)))

;; (define-public go-github-com-gopherjs-gopherjs
;;   (package
;;     (name "go-github-com-gopherjs-gopherjs")
;;     (version "0.0.0-20220221023154-0b2280d3ff96")
;;     (source
;;       (origin
;;         (method git-fetch)
;;         (uri (git-reference
;;                (url "https://github.com/gopherjs/gopherjs")
;;                (commit (go-version->git-ref version))))
;;         (file-name (git-file-name name version))
;;         (sha256
;;           (base32 "1i4xmsmwghkvcawama5sf7d6w0s4cn4jgfbcnl0lzpw8hrbfncqn"))))
;;     (build-system go-build-system)
;;     (arguments '(#:import-path "github.com/gopherjs/gopherjs"))
;;     (propagated-inputs
;;       `(("go-golang-org-x-xerrors" ,go-golang-org-x-xerrors)
;;         ("go-golang-org-x-term" ,go-golang-org-x-term)
;;         ("go-github-com-sirupsen-logrus" ,go-github-com-sirupsen-logrus)
;;         ("go-github-com-shurcool-vfsgen" ,go-github-com-shurcool-vfsgen)
;;         ("go-golang-org-x-tools" ,go-golang-org-x-tools)
;;         ("go-golang-org-x-sys" ,go-golang-org-x-sys)
;;         ("go-golang-org-x-sync" ,go-golang-org-x-sync)
;;         ("go-golang-org-x-crypto" ,go-golang-org-x-crypto)
;;         ("go-github-com-spf13-pflag" ,go-github-com-spf13-pflag)
;;         ("go-github-com-spf13-cobra" ,go-github-com-spf13-cobra)
;;         ("go-github-com-shurcool-httpfs" ,go-github-com-shurcool-httpfs)
;;         ("go-github-com-shurcool-go" ,go-github-com-shurcool-go)
;;         ("go-github-com-neelance-sourcemap" ,go-github-com-neelance-sourcemap)
;;         ("go-github-com-neelance-astrewrite"
;;          ,go-github-com-neelance-astrewrite)
;;         ("go-github-com-google-go-cmp" ,go-github-com-google-go-cmp)
;;         ("go-github-com-fsnotify-fsnotify" ,go-github-com-fsnotify-fsnotify)))
;;     (home-page "https://github.com/gopherjs/gopherjs")
;;     (synopsis "GopherJS - A compiler from Go to JavaScript")
;;     (description
;; "GopherJS compiles Go code (@url{https://golang.org/,golang.org}) to pure
;; JavaScript code.  Its main purpose is to give you the opportunity to write
;; front-end code in Go which will still run in all browsers.")
;;     (license license:bsd-2)))

;; (define-public go-github-com-gopherjs-gopherwasm
;;   (package
;;     (name "go-github-com-gopherjs-gopherwasm")
;;     (version "1.1.0")
;;     (source
;;       (origin
;;         (method git-fetch)
;;         (uri (git-reference
;;                (url "https://github.com/gopherjs/gopherwasm")
;;                (commit (string-append "v" version))))
;;         (file-name (git-file-name name version))
;;         (sha256
;;           (base32 "0cx8kpm8gxb5wiqm09z6smp9z0m6a0jdqg7lvbksrwjy0s6872h2"))))
;;     (build-system go-build-system)
;;     (arguments '(#:import-path "github.com/gopherjs/gopherwasm"))
;;     (propagated-inputs
;;       `(("go-github-com-gopherjs-gopherjs" ,go-github-com-gopherjs-gopherjs)))
;;     (home-page "https://github.com/gopherjs/gopherwasm")
;;     (synopsis "Wrapper for GopherJS and Wasm")
;;     (description
;; "@code{go-github-com-gopherjs-gopherwasm} provides a wrapper for
;; GopherJS (@code{gopherjs/js}) and Wasm (@code{syscall/js}). With
;; this, you can make your application work with both GopherJS and Wasm.")
;;     (license license:bsd-2)))

;; (define-public go-github-com-godbus-dbus-v5
;;   (package
;;     (name "go-github-com-godbus-dbus-v5")
;;     (version "5.1.0")
;;     (source
;;       (origin
;;         (method git-fetch)
;;         (uri (git-reference
;;               (url "https://github.com/godbus/dbus")
;;                (commit (string-append "v" version))))
;;         (file-name (git-file-name name version))
;;         (sha256
;;           (base32 "1kayd4x7idrhi06ahh5kqkgwzgh9icvv71mjar2d0jl486dfs8r5"))))
;;     (build-system go-build-system)
;;     (arguments
;;      '(#:import-path "github.com/godbus/dbus/v5"
;;        #:tests? #f)) ;; FIXME: tests fail
;;     (home-page "https://github.com/godbus/dbus")
;;     (synopsis "Native Go bindings for D-Bus")
;;     (description
;; "@code{go-github-com-godbus-dbus-v5} implements bindings to the D-Bus
;; message bus system.")
;;     (license license:bsd-2)))

;; (define-public go-github-com-gen2brain-beeep
;;   (package
;;     (name "go-github-com-gen2brain-beeep")
;;     (version "0.0.0-20200420150314-13046a26d502")
;;     (source
;;       (origin
;;         (method git-fetch)
;;         (uri (git-reference
;;                (url "https://github.com/gen2brain/beeep")
;;                (commit (go-version->git-ref version))))
;;         (file-name (git-file-name name version))
;;         (sha256
;;           (base32 "11m73wljir1daaqzdifjwzsh41rlc74ynsnwqk4y15flr9nnlpfg"))))
;;     (build-system go-build-system)
;;     (arguments
;;      '(#:import-path "github.com/gen2brain/beeep"))
;;     (propagated-inputs
;;       `(("go-golang-org-x-sys" ,go-golang-org-x-sys)
;;         ("go-github-com-nu7hatch-gouuid" ,go-github-com-nu7hatch-gouuid)
;;         ("go-github-com-gopherjs-gopherwasm"
;;          ,go-github-com-gopherjs-gopherwasm)
;;         ("go-github-com-godbus-dbus-v5" ,go-github-com-godbus-dbus-v5)
;;         ("go-github-com-go-toast-toast" ,go-github-com-go-toast-toast)))
;;     (home-page "https://github.com/gen2brain/beeep")
;;     (synopsis "beeep")
;;     (description
;;       "Package beeep provides a cross-platform library for sending desktop
;; notifications and beeps.")
;;     (license license:bsd-2)))

(define-public go-github-com-influxdata-influxdb1-client
  (package
    (name "go-github-com-influxdata-influxdb1-client")
    (version "0.0.0-20200827194710-b269163b24ab")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/influxdata/influxdb1-client")
             (commit (go-version->git-ref version))))
       (file-name (git-file-name name version))
       (sha256
        (base32 "0pm1j437xk7d32px60j52qm98zgn21nmaqavjflvr44zaglrz5n9"))))
    (build-system go-build-system)
    (arguments '(#:tests? #f ; tries to use network?
                 #:import-path "github.com/influxdata/influxdb1-client"))
    (home-page "https://github.com/influxdata/influxdb1-client")
    (synopsis "Go client API for InfluxDB 1.x.")
    (description synopsis)
    (license license:expat)))

(define-public go-github-com-tomasen-realip
  (package
    (name "go-github-com-tomasen-realip")
    (version "0.0.0-20180522021738-f0c99a92ddce")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/tomasen/realip")
             (commit (go-version->git-ref version))))
       (file-name (git-file-name name version))
       (sha256
        (base32 "1iz2cwks2ywwvvnbfmw3pfyz4ql7z0f8s9sdj6pzirpp75zar9nn"))))
    (build-system go-build-system)
    (arguments '(#:import-path "github.com/tomasen/realip"))
    (home-page "https://github.com/tomasen/realip")
    (synopsis "Go library to get a client's public IP")
    (description
"@code{go-github-com-tomasen-realip} can be used to get client's real
public IP, which is usually useful for logging HTTP server.")
    (license license:expat)))

(define-public go-github-com-andrew-d-go-termutil
  (package
    (name "go-github-com-andrew-d-go-termutil")
    (version "0.0.0-20150726205930-009166a695a2")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/andrew-d/go-termutil")
             (commit (go-version->git-ref version))))
       (file-name (git-file-name name version))
       (sha256
        (base32 "0py57x5s3mc31ppxbjh0lqxcmh6m70681ga0v7zpmyy6h3z2f8fb"))))
    (build-system go-build-system)
    (arguments '(#:import-path "github.com/andrew-d/go-termutil"))
    (home-page "https://github.com/andrew-d/go-termutil")
    (synopsis "Terminal utilities for golang")
    (description synopsis)
    (license license:expat)))

(define-public go-github-com-jpillora-requestlog
  (package
    (name "go-github-com-jpillora-requestlog")
    (version "1.0.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/jpillora/requestlog")
             (commit (string-append "v" version))))
       (file-name (git-file-name name version))
       (sha256
        (base32 "0jsw582c50y24w4j2vwal8010pldb5qcrpza454pqm3f2fzd9ai2"))))
    (build-system go-build-system)
    (arguments '(#:import-path "github.com/jpillora/requestlog"))
    (inputs
     `(("go-github-com-andrew-d-go-termutil"
        ,go-github-com-andrew-d-go-termutil)
       ("go-github-com-tomasen-realip" ,go-github-com-tomasen-realip)
       ("go-github-com-jpillora-ansi" ,go-github-com-jpillora-ansi)
       ("go-github-com-jpillora-sizestr" ,go-github-com-jpillora-sizestr)))
    (home-page "https://github.com/jpillora/requestlog")
    (synopsis "Simple request logging in Go")
    (description synopsis)
    (license license:expat)))

(define-public go-github-com-jpillora-ansi
  (package
    (name "go-github-com-jpillora-ansi")
    (version "1.0.2")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/jpillora/ansi")
             (commit (string-append "v" version))))
       (file-name (git-file-name name version))
       (sha256
        (base32 "11nhaq5jdab920fpsh18gji7l2zj2762kkg1x0v9y9nid149chd0"))))
    (build-system go-build-system)
    (arguments '(#:import-path "github.com/jpillora/ansi"))
    (home-page "https://github.com/jpillora/ansi")
    (synopsis "Easy to use ANSI control codes for Go")
    (description
"@code{go-github-com-jpillora-ansi} implements the ANSI VT100 control
set for use in Go.")
    (license license:expat)))

(define-public go-github-com-armon-go-socks5
  (package
    (name "go-github-com-armon-go-socks5")
    (version "0.0.0-20160902184237-e75332964ef5")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/armon/go-socks5")
             (commit (go-version->git-ref version))))
       (file-name (git-file-name name version))
       (sha256
        (base32 "104w10jf0wlxyxi35hf6frndgf0ybz21h54xjmnkivpb6slycpyq"))))
    (build-system go-build-system)
    (arguments '(#:import-path "github.com/armon/go-socks5"))
    (inputs
     `(("go-golang-org-x-net" ,go-golang-org-x-net)))
    (home-page "https://github.com/armon/go-socks5")
    (synopsis "SOCKS5 server in Golang")
    (description synopsis)
    (license license:expat)))

(define-public go-github-com-jpillora-chisel
  (package
    (name "go-github-com-jpillora-chisel")
    (version "0.0.0-20190724232113-f3a8df20e389")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/jpillora/chisel")
             (commit (go-version->git-ref version))))
       (file-name (git-file-name name version))
       (sha256
        (base32 "1vrxzavm07px3qkkpsn4wsp2fg6ghh68s1bnym6wcdg2w9258dfw"))))
    (build-system go-build-system)
    (arguments '(#:import-path "github.com/jpillora/chisel"))
    (inputs
     `(("go-golang-org-x-term" ,go-golang-org-x-term)
       ("go-golang-org-x-text" ,go-golang-org-x-text)
       ("go-golang-org-x-net" ,go-golang-org-x-net)
       ("go-golang-org-x-sys" ,go-golang-org-x-sys)
       ("go-golang-org-x-sync" ,go-golang-org-x-sync)
       ("go-golang-org-x-crypto" ,go-golang-org-x-crypto)
       ("go-github-com-jpillora-sizestr" ,go-github-com-jpillora-sizestr)
       ("go-github-com-jpillora-requestlog"
        ,go-github-com-jpillora-requestlog)
              ("go-github-com-tomasen-realip" ,go-github-com-tomasen-realip)
       ("go-github-com-jpillora-backoff" ,go-github-com-jpillora-backoff)
       ("go-github-com-jpillora-ansi" ,go-github-com-jpillora-ansi)
       ("go-github-com-gorilla-websocket" ,go-github-com-gorilla-websocket)
       ("go-github-com-fsnotify-fsnotify" ,go-github-com-fsnotify-fsnotify)
       ("go-github-com-armon-go-socks5" ,go-github-com-armon-go-socks5)
       ("go-github-com-andrew-d-go-termutil"
       ,go-github-com-andrew-d-go-termutil)))
    (home-page "https://github.com/jpillora/chisel")
    (synopsis "Fast TCP/UDP tunnel over HTTP")
    (description
"@code{go-github-com-jpillora-chisel} is a fast TCP/UDP tunnel,
transported over HTTP, secured via SSH.  Single executable including
both client and server.  Written in Go (golang).  Chisel is mainly
useful for passing through firewalls, though it can also be used to
provide a secure endpoint into your network.")
    (license license:expat)))

(define-public go-github-com-go-logfmt-logfmt
  (package
    (name "go-github-com-go-logfmt-logfmt")
    (version "0.4.0")
    (source
      (origin
        (method git-fetch)
        (uri (git-reference
              (url "https://github.com/go-logfmt/logfmt")
              (commit (string-append "v" version))))
        (file-name (git-file-name name version))
        (sha256
         (base32
          "06smxc112xmixz78nyvk3b2hmc7wasf2sl5vxj1xz62kqcq9lzm9"))))
    (build-system go-build-system)
    (arguments
     `(#:tests? #f ; fixme
       #:import-path "github.com/go-logfmt/logfmt/"))
    (native-inputs
      (list go-github-com-kr-logfmt))
    (home-page "https://github.com/go-logfmt/logfmt")
    (synopsis "Marshals and unmarshals logfmt messages")
    (description
"@code{go-github-com-go-logfmt-logfmt} implements utilities to mars
and unmarshal data in the logfmt format.  It provides an API similar
encoding/json and encoding/xml.")
    (license license:expat)))

(define-public go-github-com-kr-logfmt
  (let ((commit "19f9bcb100e6bcb308b5db29c682de01e9b3f2e6")
        (revision "0"))
    (package
      (name "go-github-com-kr-logfmt")
      (version (git-version "20210122" revision commit))
      (source (origin
                (method git-fetch)
                (uri (git-reference
                      (url "https://github.com/kr/logfmt")
                      (commit commit)))
                (file-name (git-file-name name commit))
                (sha256
                 (base32
                  "1l6322amgy092n30l6br0wzszf3l2a3dkylck3pzpvzr4lqfcyhb"))))
      (build-system go-build-system)
      (arguments
       `(#:tests? #f ; fixme
         #:import-path "https://github.com/kr/logfmt"))
      (home-page "https://pkg.go.dev/github.com/kr/logfmt?utm_source=godoc")
      (synopsis "Parse logfmt messages")
      (description "Go package for parsing log lines in the logfmt style.")
      (license license:expat))))

(define-public go-github-com-olebedev-emitter
  (let ((commit "e8d1457e6aee6368f6abda5ad334fde63e9cc3fa")
        (revision "0"))
    (package
      (name "go-github-com-olebedev-emitter")
      (version commit)
      (source (origin
                (method git-fetch)
                (uri (git-reference
                      (url "https://github.com/olebedev/emitter")
                      (commit commit)))
                (file-name (git-file-name name commit))
                (sha256
                 (base32
                  "1cqhycjd8ysfgvj7njf3y8c53gbhrpmd92dqqs6y7fxkgz5h53w5"))))
      (build-system go-build-system)
      (arguments
       `(#:tests? #f ; fixme
         #:import-path "https://github.com/olebedev/emitter"))
      (home-page "https://github.com/olebedev/emitter")
      (synopsis "Emits events in Go way")
      (description
"@code{go-github-com-olebedev-emitter} implements a channel-based pubsub
pattern.  The design goals are to use Golang concurrency model instead
of flat callbacks and to design a very simple API that is easy to consume.")
      (license license:expat))))

(define-public go-github-com-pborman-ansi
  (let ((commit "86f499584b0aace4fc5f2c82c4b47bd9d73bca80")
        (revision "0"))
    (package
      (name "go-github-com-pborman-ansi")
      (version commit)
      (source (origin
                (method git-fetch)
                (uri (git-reference
                      (url "https://github.com/pborman/ansi")
                      (commit commit)))
                (file-name (git-file-name name commit))
                (sha256
                 (base32
                  "1id2bda5yy88m3ajswbpyjkdl62rjkai7jkp6ydgnzk85vaj23va"))))
      (build-system go-build-system)
      (arguments
       `(#:tests? #f ; fixme
         #:import-path "https://github.com/pborman/ansi"))
      (home-page "https://github.com/pborman/ansi")
      (synopsis "ANSI escape sequences")
      (description "Package ansi provides ansi escape sequence processing as
defined by the ECMA-48 standard \"Control Functions for Coded Character Sets -
Fifth Edition\".")
      (license license:bsd-3))))

(define-public go-github-com-lunixbochs-vtclean
  (package
    (name "go-github-com-lunixbochs-vtclean")
    (version "1.0.0")
    (source
      (origin
        (method git-fetch)
        (uri (git-reference
               (url "https://github.com/lunixbochs/vtclean")
               (commit (string-append "v" version))))
        (file-name (git-file-name name version))
        (sha256
          (base32 "0jqn33l1kzy4dk66zbvxz7rlgkgg34s9mhc8z0lrz0i88466zhd8"))))
    (build-system go-build-system)
    (arguments '(#:import-path "github.com/lunixbochs/vtclean"))
    (home-page "https://github.com/lunixbochs/vtclean")
    (synopsis "vtclean")
    (description
      "Clean up raw terminal output by stripping escape sequences, optionally
preserving color.")
    (license license:expat)))

(define-public go-github-com-golang-protobuf-proto-for-grumble
  (package
    (name "go-github-com-golang-protobuf-proto-for-grumble")
    (version "1.3.5")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                     (url "https://github.com/golang/protobuf")
                     (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "1gkd1942vk9n8kfzdwy1iil6wgvlwjq7a3y5jc49ck4lz9rhmgkq"))))
    (build-system go-build-system)
    (arguments
     '(#:import-path "github.com/golang/protobuf/proto"
       #:unpack-path "github.com/golang/protobuf"
       ;; Requires unpackaged golang.org/x/sync/errgroup
       #:tests? #f))
    (synopsis "Go support for Protocol Buffers")
    (description "This package provides Go support for the Protocol Buffers
data serialization format.")
    (home-page "https://github.com/golang/protobuf")
    (license license:bsd-3)))

(define-public go-github-com-gorilla-websocket
  (package
    (name "go-github-com-gorilla-websocket")
    (version "1.4.2")
    (home-page "https://github.com/gorilla/websocket")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url home-page)
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32 "0mkm9w6kjkrlzab5wh8p4qxkc0icqawjbvr01d2nk6ykylrln40s"))))
    (build-system go-build-system)
    (arguments
     '(#:import-path "github.com/gorilla/websocket"))
    (synopsis "Well-tested and widely used WebSocket implementation for Go")
    (description "Gorilla WebSocket is a Go implementation of the WebSocket protocol.")
    (license license:bsd-2)))

(define-public go-gemini
  (package
    (name "go-gemini")
    (version "0.2.2")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://git.sr.ht/~adnano/go-gemini")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "1v7drlcizzj7bxcagswv7qj4aam7n3kq69viwncmrrsl82gp5ck3"))))
    (build-system go-build-system)
    (inputs
      (list go-golang-org-x-net
            go-golang-org-x-text))
    (arguments
     `(#:import-path "git.sr.ht/~adnano/go-gemini"))
    (home-page "https://git.sr.ht/~adnano/go-gemini")
    (synopsis "Go implementation of the Gemini protocol")
    (description
"@code{go-gemini} implements the Gemini protocol in Go.  It provides an
API similar to that of net/http to facilitate the development of Gemini
clients and servers.")
    (license license:gpl3+)))

(define-public go-gopkg-in-tylerb-is-v1
  (package
    (name "go-gopkg-in-tylerb-is-v1")
    (version "1.1.2")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://gopkg.in/tylerb/is.v1")
             (commit (string-append "v" version))))
       (file-name (git-file-name name version))
       (sha256
        (base32 "1xva69xnvwfkp8axlj62vga20iafkipanvd95csbx9cwnsdk2xif"))))
    (build-system go-build-system)
    (arguments
     '(#:import-path
       "gopkg.in/tylerb/is.v1"
       #:unpack-path
       "gopkg.in/tylerb/is.v1"))
    (home-page "https://gopkg.in/tylerb/is.v1")
    (synopsis "is")
    (description
     "Is provides a quick, clean and simple framework for writing Go tests.")
    (license license:expat)))

(define-public go-github-com-k0kubun-go-ansi
  (package
    (name "go-github-com-k0kubun-go-ansi")
    (version "0.0.0-20180517002512-3bf9e2903213")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/k0kubun/go-ansi")
             (commit (go-version->git-ref version))))
       (file-name (git-file-name name version))
       (sha256
        (base32 "117afax4l268rbswf02icbgxncmd1pk2abkz7cv26iyszi8l26dq"))))
    (build-system go-build-system)
    (arguments '(#:import-path "github.com/k0kubun/go-ansi"))
    (home-page "https://github.com/k0kubun/go-ansi")
    (synopsis "go-ansi")
    (description
     "Windows-portable ANSI escape sequence utility for Go language")
    (license license:expat)))

(define-public go-github-com-russross-blackfriday-v2
  (package
    (name "go-github-com-russross-blackfriday-v2")
    (version "2.1.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/russross/blackfriday")
             (commit (string-append "v" version))))
       (file-name (git-file-name name version))
       (sha256
        (base32 "0d1rg1drrfmabilqjjayklsz5d0n3hkf979sr3wsrw92bfbkivs7"))))
    (build-system go-build-system)
    (arguments '(#:import-path "github.com/russross/blackfriday/v2"))
    (home-page "https://github.com/russross/blackfriday")
    (synopsis "Blackfriday")
    (description "Package blackfriday is a markdown processor.")
    (license license:bsd-2)))

(define-public go-github-com-denisbrodbeck-machineid
  (package
    (name "go-github-com-denisbrodbeck-machineid")
    (version "1.0.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/denisbrodbeck/machineid")
             (commit (string-append "v" version))))
       (file-name (git-file-name name version))
       (sha256
        (base32 "075rqb2f9hla9jwc6823jkkb3xcv6azz3phndbssssn2dps07cib"))))
    (build-system go-build-system)
    (arguments
     '(#:import-path "github.com/denisbrodbeck/machineid"
       #:tests? #f)) ;; FIXME
    (home-page "https://github.com/denisbrodbeck/machineid")
    (synopsis "machineid provides support for reading the unique machine ids")
    (description
"Package machineid provides support for reading the unique machine id
of most OSs (without admin privileges).")
    (license license:expat)))

(define-public go-github-com-kalafut-imohash
  (package
    (name "go-github-com-kalafut-imohash")
    (version "1.0.2")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/kalafut/imohash")
             (commit (string-append "v" version))))
       (file-name (git-file-name name version))
       (sha256
        (base32 "0c6rzzxcw89qz9q96ck4xwm3vavndc737drcv0s70p7w7qxv620w"))))
    (build-system go-build-system)
    (arguments '(#:import-path "github.com/kalafut/imohash"))
    (propagated-inputs
     `(("go-gopkg-in-tylerb-is-v1" ,go-gopkg-in-tylerb-is-v1)
       ("go-github-com-twmb-murmur3" ,go-github-com-twmb-murmur3)))
    (home-page "https://github.com/kalafut/imohash")
    (synopsis "imohash")
    (description
"Package imohash implements a fast, constant-time hash for files.  It is
based atop murmurhash3 and uses file size and sample data to construct
the hash.")
    (license license:expat)))

(define-public go-github-com-schollz-cli-v2
  (package
    (name "go-github-com-schollz-cli-v2")
    (version "2.2.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/schollz/cli")
             (commit (string-append "v" version))))
       (file-name (git-file-name name version))
       (sha256
        (base32 "0wlqfhsrfib4b5b5xlkmgwglpzajjabrf4wisp7q8nvnw9ky86jh"))))
    (build-system go-build-system)
    (arguments
     '(#:import-path "github.com/schollz/cli/v2"
       #:tests? #f))
    (propagated-inputs
     `(("go-gopkg-in-yaml-v2" ,go-gopkg-in-yaml-v2)
       ("go-github-com-cpuguy83-go-md2man-v2"
        ,go-github-com-cpuguy83-go-md2man-v2)
       ("go-github-com-burntsushi-toml" ,go-github-com-burntsushi-toml)))
    (home-page "https://github.com/schollz/cli")
    (synopsis "Simple, fast, and fun package for building command line apps")
    (description
"Package cli provides a minimal framework for creating and organizing
command line Go applications.")
    (license license:expat)))

(define-public go-github-com-schollz-logger
  (package
    (name "go-github-com-schollz-logger")
    (version "1.2.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/schollz/logger")
             (commit (string-append "v" version))))
       (file-name (git-file-name name version))
       (sha256
        (base32 "1680348j54vwfx7sczygchrd9dabnycj3mpxg3fmpf9a356vd2af"))))
    (build-system go-build-system)
    (arguments '(#:import-path "github.com/schollz/logger"))
    (home-page "https://github.com/schollz/logger")
    (synopsis "Simplistic, opinionated logging for Golang")
    (description "Simplistic, opinionated logging for Golang.")
    (license license:expat)))

(define-public go-github-com-schollz-mnemonicode
  (package
    (name "go-github-com-schollz-mnemonicode")
    (version "1.0.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/schollz/mnemonicode")
             (commit (string-append "v" version))))
       (file-name (git-file-name name version))
       (sha256
        (base32 "056jm384yfry3l4qm68j65x32mx9khizhzqrd347w65c4dnrys1s"))))
    (build-system go-build-system)
    (arguments '(#:import-path "github.com/schollz/mnemonicode"))
    (propagated-inputs `(("go-golang-org-x-text" ,go-golang-org-x-text)))
    (home-page "https://github.com/schollz/mnemonicode")
    (synopsis "Mnemonicode")
    (description "Package mnemonicode.")
    (license license:expat)))

(define-public go-github-com-schollz-pake-v3
  (package
    (name "go-github-com-schollz-pake-v3")
    (version "3.0.2")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/schollz/pake")
             (commit (string-append "v" version))))
       (file-name (git-file-name name version))
       (sha256
        (base32 "0cz4ql8j693qifjngb6bvbgm71zp9p54ii1pr64shgchq84p73zk"))))
    (build-system go-build-system)
    (arguments '(#:import-path "github.com/schollz/pake/v3"))
    (propagated-inputs
     `(("go-github-com-tscholl2-siec" ,go-github-com-tscholl2-siec)
       ("go-github-com-stretchr-testify" ,go-github-com-stretchr-testify)
       ("go-github-com-davecgh-go-spew" ,go-github-com-davecgh-go-spew)))
    (home-page "https://github.com/schollz/pake")
    (synopsis "pake")
    (description
"This library will help you allow two parties to generate a mutual
secret key by using a weak key that is known to both beforehand
(e.g.  via some other channel of communication).  This is a
simple API for an implementation of password-authenticated
key exchange (PAKE).  This protocol is derived from
@url{https://crypto.stanford.edu/~dabo/cryptobook/BonehShoup_0_4.pdf,Dan
Boneh and Victor Shoup's cryptography book} (pg 789, \"PAKE2 protocol).
I decided to create this library so I could use PAKE in my file-transfer
utility, @url{https://github.com/schollz/croc,croc}.")
    (license license:expat)))

(define-public go-github-com-schollz-peerdiscovery
  (package
    (name "go-github-com-schollz-peerdiscovery")
    (version "1.6.10")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/schollz/peerdiscovery")
             (commit (string-append "v" version))))
       (file-name (git-file-name name version))
       (sha256
        (base32 "1415qgm0hm07j6ncdjf3bac1zkf5fkbdas1358b3gp2gv5qhbyvv"))))
    (build-system go-build-system)
    (arguments
     '(#:import-path "github.com/schollz/peerdiscovery"
       #:tests? #f))
    (propagated-inputs
     `(("go-golang-org-x-sys" ,go-golang-org-x-sys)
       ("go-golang-org-x-net" ,go-golang-org-x-net)
       ("go-github-com-stretchr-testify" ,go-github-com-stretchr-testify)))
    (home-page "https://github.com/schollz/peerdiscovery")
    (synopsis "peerdiscovery")
    (description
"Pure-Go library for cross-platform local peer discovery using UDP
multicast.")
    (license license:expat)))

(define-public go-github-com-schollz-progressbar-v3
  (package
    (name "go-github-com-schollz-progressbar-v3")
    (version "3.8.5")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/schollz/progressbar")
             (commit (string-append "v" version))))
       (file-name (git-file-name name version))
       (sha256
        (base32 "1hn00j5d5qcnsf7dvskqavrln0icz9gcfwzv8amh1s13xirl0g6p"))))
    (build-system go-build-system)
    (arguments
     '(#:import-path "github.com/schollz/progressbar/v3"
       #:tests? #f))
    (propagated-inputs
     `(("go-golang-org-x-term" ,go-golang-org-x-term)
       ("go-golang-org-x-sys" ,go-golang-org-x-sys)
       ("go-golang-org-x-crypto" ,go-golang-org-x-crypto)
       ("go-github-com-stretchr-testify" ,go-github-com-stretchr-testify)
       ("go-github-com-mitchellh-colorstring"
        ,go-github-com-mitchellh-colorstring)
       ("go-github-com-mattn-go-runewidth" ,go-github-com-mattn-go-runewidth)
       ("go-github-com-mattn-go-isatty" ,go-github-com-mattn-go-isatty)
       ("go-github-com-k0kubun-go-ansi" ,go-github-com-k0kubun-go-ansi)
       ("go-github-com-davecgh-go-spew" ,go-github-com-davecgh-go-spew)))
    (home-page "https://github.com/schollz/progressbar")
    (synopsis "progressbar")
    (description
"This package provides a very simple thread-safe progress bar which
should work on every OS without problems.  I needed a progressbar for
@url{https://github.com/schollz/croc,croc} and everything I tried had
problems, so I made another one.  In order to be OS agnostic I do not plan
to support @url{https://github.com/schollz/progressbar/issues/6,multi-line
outputs}.")
    (license license:expat)))

(define-public go-github-com-cpuguy83-go-md2man-v2
  (package
    (name "go-github-com-cpuguy83-go-md2man-v2")
    (version "2.0.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/cpuguy83/go-md2man")
             (commit (string-append "v" version))))
       (file-name (git-file-name name version))
       (sha256
        (base32 "051ljpzf1f5nh631lvn53ziclkzmx5lza8545mkk6wxdfnfdcx8f"))))
    (build-system go-build-system)
    (arguments '(#:import-path "github.com/cpuguy83/go-md2man/v2"))
    (propagated-inputs
     `(("go-github-com-russross-blackfriday-v2"
        ,go-github-com-russross-blackfriday-v2)))
    (home-page "https://github.com/cpuguy83/go-md2man")
    (synopsis "go-md2man")
    (description "Converts markdown into roff (man pages).")
    (license license:expat)))

(define-public go-github-com-cpuguy83-go-md2man
  (package
    (name "go-github-com-cpuguy83-go-md2man")
    (version "1.0.10")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/cpuguy83/go-md2man")
             (commit (string-append "v" version))))
       (file-name (git-file-name name version))
       (sha256
        (base32 "1bqkf2bvy1dns9zd24k81mh2p1zxsx2nhq5cj8dz2vgkv1xkh60i"))))
    (build-system go-build-system)
    (arguments '(#:import-path "github.com/cpuguy83/go-md2man"))
    (propagated-inputs
     `(("go-github-com-russross-blackfriday"
        ,go-github-com-russross-blackfriday)))
    (home-page "https://github.com/cpuguy83/go-md2man")
    (synopsis "go-md2man")
    (description
     "Work in Progress.  This still needs a lot of help to be complete, or even
usable!")
    (license license:expat)))

(define-public go-github-com-mitchellh-colorstring
  (package
    (name "go-github-com-mitchellh-colorstring")
    (version "0.0.0-20190213212951-d06e56a500db")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/mitchellh/colorstring")
             (commit (go-version->git-ref version))))
       (file-name (git-file-name name version))
       (sha256
        (base32 "1d2mi5ziszfzdgaz8dg4b6sxa63nw1jnsvffacqxky6yz9m623kn"))))
    (build-system go-build-system)
    (arguments '(#:import-path "github.com/mitchellh/colorstring"))
    (home-page "https://github.com/mitchellh/colorstring")
    (synopsis "colorstring")
    (description
"Package colorstring provides functions for colorizing strings for terminal
output.")
    (license license:expat)))

(define-public go-github-com-tscholl2-siec
  (package
    (name "go-github-com-tscholl2-siec")
    (version "0.0.0-20210707234609-9bdfc483d499")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/tscholl2/siec")
             (commit (go-version->git-ref version))))
       (file-name (git-file-name name version))
       (sha256
        (base32 "0cyl982hkvdp4y5lq152w46xbxqzd2k0vggzjkzdb0pbirbq3ym9"))))
    (build-system go-build-system)
    (arguments '(#:import-path "github.com/tscholl2/siec"))
    (home-page "https://github.com/tscholl2/siec")
    (synopsis "siec")
    (description "Super-Isolated Elliptic Curve Implementation in Go")
    (license license:expat)))

(define-public go-gopkg-in-irc-v3
  (package
    (name "go-gopkg-in-irc-v3")
    (version "3.1.4")
    (source
      (origin
        (method git-fetch)
        (uri (git-reference
               (url "https://gopkg.in/irc.v3")
               (commit (string-append "v" version))))
        (file-name (git-file-name name version))
        (sha256
          (base32 "0f2vv947yf9ygy8ylwqkd9yshybfdsbsp9pffjyvm7l7rnq5da60"))))
    (build-system go-build-system)
    (arguments
      '(;; https://paste.sr.ht/~whereiseveryone/784d068887a65c1b869caa7d7c2077d28a2b2187
        #:tests? #f
        #:import-path "gopkg.in/irc.v3" #:unpack-path "gopkg.in/irc.v3"))
    (propagated-inputs
      `(("go-gopkg-in-yaml-v2" ,go-gopkg-in-yaml-v2)
        ("go-github-com-stretchr-testify" ,go-github-com-stretchr-testify)))
    (home-page "https://gopkg.in/irc.v3")
    (synopsis "Low-level IRC library for Go")
    (description "Package irc provides a simple IRC library meant as a building
block for other projects.")
    (license license:expat)))

(define-public go-github-com-aryann-difflib
  (let ((commit "ff5ff6dc229b1f52bcc9e3c716688a8ca4378062")
        (revision "0"))
    (package
      (name "go-github-com-aryann-difflib")
      (version (git-version "0.0.0" revision commit))
      (source
       (origin
         (method git-fetch)
         (uri
          (git-reference
           (url "https://github.com/aryann/difflib")
           (commit commit)))
         (file-name (git-file-name name version))
         (sha256
          (base32 "0z2m4pg5flwkvwgym4w6cynmklc9v8q5bwa6gag0wv1mx5srr8a1"))))
      (build-system go-build-system)
      (arguments
       `(#:import-path "github.com/aryann/difflib"))
      (home-page "https://github.com/aryann/difflib")
      (synopsis "Go library for diffing two sequences of text")
      (description
"@code{go-github-com-aryann-difflib} is a simple library written in Go
for diffing two sequences of text.")
      (license license:expat))))

(define-public go-git-sr-ht--sircmpwn-getopt
  (package
    (name "go-git-sr-ht--sircmpwn-getopt")
    (version "1.0.0")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://git.sr.ht/~sircmpwn/getopt")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "0f9rammnmhaz21qkmz7qf76r8jlzi323g05ps3j7gwrxlw7442a6"))))
    (build-system go-build-system)
    (arguments
     (list #:import-path "git.sr.ht/~sircmpwn/getopt"))
    (propagated-inputs (list go-github-com-stretchr-testify))
    (home-page "https://git.sr.ht/~sircmpwn/getopt")
    (synopsis "POSIX getopt for Go")
    (description
     "The getopt package is a POSIX-compatible implementation of getopt(3)
for Go.")
    (license license:bsd-3)))

(define-public go-github-com-creack-pty
  (package
    (name "go-github-com-creack-pty")
    (version "1.1.18")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/creack/pty")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "1qqhcgfym0napz8damj7dhfw28g2qn2f5h3lr93i0sxawq926yzc"))))
    (build-system go-build-system)
    (arguments
     (list #:import-path "github.com/creack/pty"
           #:modules '((ice-9 popen)
                       (ice-9 textual-ports)
                       (guix build go-build-system)
                       (guix build utils))
           #:phases
           #~(modify-phases %standard-phases
               (add-after 'unpack 'regenerate-types
                 (lambda* (#:key import-path #:allow-other-keys)
                   ;; Generated files are included (ztypes_*). We need to remake
                   ;; them with Cgo.
                   (with-directory-excursion (string-append "src/" import-path)
                     (let* ((go-arch
                             #$(car (guixrus-go-target
                                     (or (%current-target-system)
                                         (nix-system->gnu-triplet (%current-system))))))
                            (file (string-append "ztypes_" go-arch ".go"))
                            (pipe (open-input-pipe "go tool cgo -godefs types.go"))
                            (text (get-string-all pipe)))
                       (close-pipe pipe)
                       (for-each delete-file
                         (find-files (getcwd) (file-name-predicate
                                               "ztypes_[a-zA-Z0-9_]+.go")))
                       (call-with-output-file file
                         (lambda (port)
                           (display text port))))))))))
    (home-page "https://github.com/creack/pty")
    (synopsis "Pseudoterminal handling in Go")
    (description
     "The pty package provides functions for working with Unix pseudoterminals.")
    (license license:expat)))

(define-public go-github-com-emersion-go-textwrapper
  (package
    (name "go-github-com-emersion-go-textwrapper")
    (version "0.0.0-20200911093747-65d896831594")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/emersion/go-textwrapper")
                    (commit (go-version->git-ref version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "1lh9d7zvj6gm1rr6sv5xlagklgx9d666hq5srd37a4sdcjkbiqmq"))))
    (build-system go-build-system)
    (arguments
     (list #:import-path "github.com/emersion/go-textwrapper"))
    (home-page "https://github.com/emersion/go-textwrapper")
    (synopsis "Text-wrapping writer for Go")
    (description
     "The textwrapper package provides a writer that wraps long text lines to
a specified length.")
    (license license:expat)))

(define-public go-github-com-emersion-go-message
  (package
    (name "go-github-com-emersion-go-message")
    (version "0.16.0")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/emersion/go-message")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "1j5qdhsna28xcs843zsiccw700rld5hin466dl0n3a0ax1w13ay0"))))
    (build-system go-build-system)
    (arguments
     (list #:import-path "github.com/emersion/go-message"))
    (propagated-inputs (list go-golang-org-x-text
                             go-github-com-emersion-go-textwrapper))
    (home-page "https://github.com/emersion/go-message")
    (synopsis "Internet messages and MIME for Go")
    (description
     "The message package implements the Internet Message Format and Multipurpose
Internet Mail Extensions in Go.")
    (license license:expat)))

(define-public go-github-com-emersion-go-sasl
  (let ((commit "240c8404624e076f633766c16adbe96c7ac516b7")
        (revision "0"))
    (package
      (name "go-github-com-emersion-go-sasl")
      (version (git-version "0.0.0" revision commit))
      (source
        (origin
          (method git-fetch)
          (uri (git-reference
                (url "https://github.com/emersion/go-sasl")
                (commit commit)))
          (sha256
           (base32
            "1py18p3clp474xhx6ypyp0bgv6n1dfm24m95cyyqb0k3vibar6ih"))
          (file-name (git-file-name name version))))
      (build-system go-build-system)
      (arguments
       (list #:import-path "github.com/emersion/go-sasl"))
      (home-page "https://github.com/emersion/go-sasl")
      (synopsis "SASL library written in Go")
      (description "This package provides a SASL library written in Go.")
      (license license:expat))))

(define-public go-github-com-emersion-go-imap
  (package
    (name "go-github-com-emersion-go-imap")
    (version "1.2.1")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/emersion/go-imap")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "0ak2ysvfcc9w0g1070msis8x9sh6gzvf0nd65ks594siwbmqddw8"))))
    (build-system go-build-system)
    (arguments
     (list #:import-path "github.com/emersion/go-imap"))
    (propagated-inputs (list go-golang-org-x-text
                             go-github-com-emersion-go-sasl
                             go-github-com-emersion-go-message))
    (home-page "https://github.com/emersion/go-imap")
    (synopsis "IMAP4rev1 library written in Go")
    (description
     "The imap package provides an IMAP4rev1 library written in Go.  It
can be used to build IMAP clients and servers.")
    (license license:expat)))

(define-public go-github-com-emersion-go-imap-sortthread
  (package
    (name "go-github-com-emersion-go-imap-sortthread")
    (version "1.2.0")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/emersion/go-imap-sortthread")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "1cfbgz1l5angnj52v9pxwggai2shx0h78ffcp7j4r4lr7lzflnwz"))))
    (build-system go-build-system)
    (arguments
     (list #:import-path "github.com/emersion/go-imap-sortthread"))
    (propagated-inputs (list go-golang-org-x-text
                             go-github-com-emersion-go-sasl
                             go-github-com-emersion-go-imap))
    (home-page "https://github.com/emersion/go-imap-sortthread")
    (synopsis "Sorting and threading of messages for the imap package")
    (description
     "The sortthread package implements message sorting and threading for
@code{go-github-com-emersion-go-imap}.")
    (license license:expat)))

(define-public go-github-com-emersion-go-maildir
  (package
    (name "go-github-com-emersion-go-maildir")
    (version "0.3.0")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/emersion/go-maildir")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "1rs9kbacjpcza25pmdkbm7sdm7r6gq4g44nihi9asyrvspx96zf2"))))
    (build-system go-build-system)
    (arguments
     (list #:import-path "github.com/emersion/go-maildir"))
    (home-page "https://github.com/emersion/go-maildir")
    (synopsis "Maildir interface for Go")
    (description
     "The maildir package provides an interface to mailboxes in the Maildir
format.")
    (license license:expat)))

(define-public go-github-com-lucasb-eyer-go-colorful
  (package
    (name "go-github-com-lucasb-eyer-go-colorful")
    (version "1.2.0")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/lucasb-eyer/go-colorful")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "08c3fkf27r16izjjd4w94xd1z7w1r4mdalbl53ms2ka2j465s3qs"))))
    (build-system go-build-system)
    (inputs (list go-golang-org-x-image))
    (arguments
     (list #:import-path "github.com/lucasb-eyer/go-colorful"))
    (home-page "https://github.com/lucasb-eyer/go-colorful")
    (synopsis "Library for playing with colors in Go")
    (description
     "The colorful package providos a library for using colors in Go.
colorful stores colors in RGB and provides methods for converting these to
various color spaces.")
    (license license:expat)))

(define-public go-github-com-disintegration-imaging
  (package
    (name "go-github-com-disintegration-imaging")
    (version "1.6.2")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/disintegration/imaging")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "1sl201nmk601h0aii4234sycn4v2b0rjxf8yhrnik4yjzd68q9x5"))))
    (build-system go-build-system)
    (inputs (list go-golang-org-x-image))
    (arguments
     `(#:import-path "github.com/disintegration/imaging"))
    (home-page "https://github.com/disintegration/imaging")
    (synopsis "Imaging is a simple image processing package for Go")
    (description
     "@code{disintegration-imaging} provides basic image processing
functions such as @code{resize}, @code{rotate}, @code{crop},
@code{brightness/contrast}, @code{adjustments}, etc.")
    (license license:expat)))

(define-public go-github-com-zyedidia-clipboard
  (package
    (name "go-github-com-zyedidia-clipboard")
    (version "1.0.3")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/zyedidia/clipboard")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "134vnx0r51f08b37yaymlxlfl14qv6r8yzgqz7dxxn1zw9197b3q"))))
    (build-system go-build-system)
    (arguments
       `(#:import-path "github.com/zyedidia/clipboard"
         #:tests? #f
         #:phases
         (modify-phases %standard-phases
           (delete 'build))))
    (home-page "https://github.com/zyedidia/clipboard")
    (synopsis "Clipboard for golang")
    (description
"@code{zyedidia-clipboard} provides copying and pasting to the Clipboard
for Go.")
    (license license:expat)))

(define-public go-github-com-lithammer-fuzzysearch
  (package
    (name "go-github-com-lithammer-fuzzysearch")
    (version "1.1.5")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/lithammer/fuzzysearch")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "1b036sm42cf64diwlqhx24vxy6g5afrmfbdfyqhpg8zrii3lpwns"))))
    (build-system go-build-system)
    (propagated-inputs (list go-golang-org-x-text))
    (arguments
     (list #:import-path "github.com/lithammer/fuzzysearch"
           #:tests? #f ; Source-only package.
           #:phases
           #~(modify-phases %standard-phases
               ;; Source-only package.
               (delete 'build))))
    (home-page "https://github.com/lithammer/fuzzysearch")
    (synopsis "Tiny and fast fuzzy search in Go")
    (description
     "A speedy fuzzy matching package for Go inspired by the JavaScript
library bevacqua/fuzzysearch.")
    (license license:expat)))

(define-public go-github-com-rivo-uniseg
  (package
    (name "go-github-com-rivo-uniseg")
    (version "0.2.0")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/rivo/uniseg")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "0j7h22vfmjj562vr8gpsyrkrwp1pq9ayh5fylv24skxb467g9f0q"))))
    (build-system go-build-system)
    (arguments
     (list #:import-path "github.com/rivo/uniseg"))
    (home-page "https://github.com/rivo/uniseg")
    (synopsis "Unicode text segmentation for Go")
    (description
     "The uniseg package provides a tool to iterate over grapheme clusters.
This may be used to determine the number of user-perceived characters, to
split strings in their intended places, or to extract individual characters
which form a unit.")
    (license license:expat)))

(define-public go-github-nu7hatch-gouuid
  (let ((commit "179d4d0c4d8d407a32af483c2354df1d2c91e6c3")
        (revision "0"))
    (package
      (name "go-github-nu7hatch-gouuid")
      (version (git-version "0.0.0" revision commit))
      (source (origin
                (method git-fetch)
                (uri (git-reference
                       (url "https://github.com/nu7hatch/gouuid")
                       (commit commit)))
                (file-name (git-file-name name version))
                (sha256
                 (base32
                  "1isyfix5w1wm26y3a15ha3nnpsxqaxz5ngq06hnh6c6y0inl2fwj"))))
      (build-system go-build-system)
      (arguments
       `(#:import-path "github.com/nu7hatch/gouuid"
         #:tests? #f
         #:phases
         (modify-phases %standard-phases
           (delete 'build)))) ; TODO
      (home-page "https://github.com/nu7hatch/gouuid")
      (synopsis "Go binding for libuuid")
      (description
"@code{go-golang-org-x-image} provides immutable UUID structs and the
functions NewV3, NewV4, NewV5 and Parse() for generating versions 3,
4 and 5 UUIDs as specified in RFC 4122.")
      (license license:expat))))

(define-public go-github-com-russross-blackfriday-for-gomuks
  (package
    (name "go-github-com-russross-blackfriday-for-gomuks")
    (version "2.1.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/russross/blackfriday")
             (commit (string-append "v" version))))
       (file-name (git-file-name name version))
       (sha256
        (base32
         "0d1rg1drrfmabilqjjayklsz5d0n3hkf979sr3wsrw92bfbkivs7"))))
    (build-system go-build-system)
    (arguments
     '(#:import-path "github.com/russross/blackfriday"))
    (propagated-inputs
     (list go-github-com-shurcool-sanitized-anchor-name))
    (native-inputs
     (list go-github-com-pmezard-go-difflib))
    (home-page "https://github.com/russross/blackfriday")
    (synopsis "Markdown processor in Go")
    (description "Blackfriday is a Markdown processor in Go.")
    (license license:bsd-2)))

(define-public go-github-com-mattn-go-sqlite3-for-gomuks
  (package
    (name "go-github-com-mattn-go-sqlite3-for-gomuks")
    (version "1.14.9")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/mattn/go-sqlite3")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "0nj4nh966niyf97wwqv1343d5a87rfbixg7nkpz7x6masbsgp3sg"))))
    (build-system go-build-system)
    (arguments
     `(#:import-path "github.com/mattn/go-sqlite3"))
    (home-page "https://github.com/mattn/go-sqlite3")
    (synopsis "Sqlite3 driver for Go")
    (description "This package provides a Sqlite3 driver for Go using
@code{database/sql}.")
    (license license:expat)))

(define-public go-github-com-alecthomas-chroma-for-gomuks
  (package
    (name "go-github-com-alecthomas-chroma-for-gomuks")
    (version "0.8.2")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/alecthomas/chroma")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "0928myh6dx4yvs4yp9mjcsiwcv6nqivbh370aa2rr0kzsln0ncqa"))))
    (build-system go-build-system)
    (arguments
     `(#:import-path "github.com/alecthomas/chroma"))
    (native-inputs
     (list go-github-com-dlclark-regexp2
           go-github-com-alecthomas-assert
           go-github-com-alecthomas-colour
           go-github-com-alecthomas-repr
           go-github-com-mattn-go-isatty
           go-github-com-sergi-go-diff))
    (home-page "https://github.com/alecthomas/chroma/")
    (synopsis "General purpose syntax highlighter in pure Go")
    (description "Chroma takes source code and other structured text and
converts it into syntax highlighted HTML, ANSI-coloured text, etc.")
    (license license:expat)))

(define-public go-etcd-io-bbolt-for-gomuks
  (package
    (name "go-etcd-io-bbolt-for-gomuks")
    (version "1.3.5")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/etcd-io/bbolt")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "1h64gipvcg7060byv5wjlf524kqwj12p3v08kfh4ygv46vpm8p2r"))))
    (build-system go-build-system)
    (arguments
     `(#:import-path "go.etcd.io/bbolt"))
    (propagated-inputs
     (list go-golang-org-x-sys))
    (home-page "https://pkg.go.dev/go.etcd.io/bbolt/")
    (synopsis "Low-level key/value store in Go")
    (description "This package implements a low-level key/value store in Go.")
    (license license:expat)))

(define-public go-golang-org-x-net-for-gomuks
  (let ((commit "d418f374d30933c6c7db22cf349625c295a5afaa")
        (revision "4"))
    (package
      (name "go-golang-org-x-net-for-gomuks")
      (version (git-version "0.0.0" revision commit))
      (source (origin
                (method git-fetch)
                (uri (git-reference
                      (url "https://go.googlesource.com/net")
                      (commit commit)))
                (file-name (git-file-name name version))
                (sha256
                 (base32
                  "0viafsji8zba66wwdv3xkr8qlc6xa4vcgwgd3q055b3gw5abaak9"))))
      (build-system go-build-system)
      (arguments
       `(#:import-path "golang.org/x/net"
         ; Source-only package
         #:tests? #f
         #:phases
         (modify-phases %standard-phases
           (delete 'build))))
      (synopsis "Go supplemental networking libraries")
      (description "This package provides supplemental Go networking libraries.")
      (home-page "https://go.googlesource.com/net")
      (license license:bsd-3))))

(define-public go-golang-org-x-image-for-gomuks
  (let ((commit "ac19c3e999fb6ea69c828f9e17148f37276c38e2")
        (revision "1"))
    (package
      (name "go-golang-org-x-image-for-gomuks")
      (version (git-version "0.0.0" revision commit))
      (source (origin
                (method git-fetch)
                (uri (git-reference
                       (url "https://go.googlesource.com/image")
                       (commit commit)))
                (file-name (string-append "go.googlesource.com-image-"
                                          version "-checkout"))
                (sha256
                 (base32
                  "1ildk41qcd3k17d91b0f7kqn22f47sgyxaar8xaz0fmaawsp0y2p"))))
      (build-system go-build-system)
      (arguments
       `(#:import-path "golang.org/x/image"
         ; Source-only package
         #:tests? #f
         #:phases
         (modify-phases %standard-phases
           (delete 'build))))
      (home-page "https://go.googlesource.com/image")
      (synopsis "Supplemental Go image libraries")
      (description "This package provides supplemental Go libraries for image
processing.")
      (license license:bsd-3))))

(define-public go-github-com-kyokomi-emoji
  (package
    (name "go-github-com-kyokomi-emoji")
    (version "2.2.8")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/kyokomi/emoji")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "11wriagjwkrrnjsv264hwdbp4wiwmclvj67kybf6rhfx5ly74n31"))))
    (build-system go-build-system)
    (arguments
     `(#:import-path "github.com/kyokomi/emoji"))
    (home-page "https://github.com/kyokomi/emoji")
    (synopsis "Emoji terminal output for golang")
    (description
"@code{go-github-com-kyokomi-emoji} is a library for displaying emojis
to the terminal.")
    (license license:expat)))

(define-public go-github-com-gabriel-vasile-mimetype
  (package
    (name "go-github-com-gabriel-vasile-mimetype")
    (version "1.2.0")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/gabriel-vasile/mimetype")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "0ysb0pjhyr9b7q2y39b5hpwsaidgfl42gd07yj34mgmb9wfjb7ch"))))
    (build-system go-build-system)
    (arguments
     `(#:import-path "github.com/gabriel-vasile/mimetype"
       ;; tree_test.go:15: open supported_mimes.md: permission denied
       #:tests? #f
       #:phases
       (modify-phases %standard-phases
         ;; system-error "open-fdes" "~A" ("Permission denied") (13)
         (delete 'reset-gzip-timestamps))))
    (home-page "https://github.com/gabriel-vasile/mimetype")
    (synopsis "Golang library for media type and file extension")
    (description
"Golang library for media type and file extension detection, based on
magic numbers.")
    (license license:expat)))

(define-public go-gopkg-in-vansante-go-ffprobe
  (package
    (name "go-gopkg-in-vansante-go-ffprobe")
    (version "2.0.2")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/vansante/go-ffprobe")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "0vzw1qgi2sjxfrk0j1bw6yx18yqzcd5m286b7x7np4wqrw969mpl"))))
    (build-system go-build-system)
    (arguments
     `(#:import-path "gopkg.in/vansante/go-ffprobe.v2"))
    (inputs
      (list ffmpeg))
    (home-page "https://pkg.go.dev/gopkg.in/vansante/go-ffprobe.v2")
    (synopsis "Golang library for ffprobe")
    (description
"Small library for executing an ffprobe process on a given file and
getting an easy to use struct representing the returned ffprobe data.")
    (license license:expat)))

(define-public go-github-com-tulir-maulogger
  (package
    (name "go-github-com-tulir-maulogger")
    (version "2.3.2")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/tulir/maulogger")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "1kxwx2fby58iws78dlb4cgbgwak35y5b9hswrlrv4gi0pbawwnhn"))))
    (build-system go-build-system)
    (arguments
     `(#:import-path "github.com/tulir/maulogger"))
    (home-page "https://maunium.net/go/maulogger/")
    (synopsis "Logger in Go")
    (description "MauLogger is a logger for Go programs.")
    (license license:mpl2.0)))

(define-public go-github-com-aead-siphash
  (package
    (name "go-github-com-aead-siphash")
    (version "1.0.1")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/aead/siphash")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "01kd1z82sc4nh3nj9c25aryyp396s7jrqc2kz9d7qq1vy2hdbznc"))))
    (build-system go-build-system)
    (arguments
     `(#:import-path "github.com/aead/siphash"))
    (home-page "https://github.com/aead/siphash")
    (synopsis "Go implementation of SipHash-64/128")
    (description "SipHash is a family of pseudo-random functions optimized for
speed on short messages.  It computes a 64-bit or 128 bit message authentication
code from a variable-length message and 128-bit secret key.  This implementation
uses the recommended parameters c=2 and d=4.")
    (license license:expat)))

(define-public go-github-com-kkdai-bstream
  (package
    (name "go-github-com-kkdai-bstream")
    (version "1.0.0")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/kkdai/bstream")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "02brc58hhkkfhgb4yxjv3wshq355w533q7d49qrlfkhk265qph7w"))))
    (build-system go-build-system)
    (arguments
     `(#:import-path "github.com/kkdai/bstream"))
    (home-page "https://github.com/kkdai/bstream")
    (synopsis "Bit Stream helper in Golang")
    (description "Bit Stream helper in Golang.")
    (license license:expat)))

(define-public go-github-com-tidwall-pretty
  (package
    (name "go-github-com-tidwall-pretty")
    (version "1.2.0")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/tidwall/pretty")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "11zi5hxb75yapgxq67r4lmv8n910iqmw7994ig1fy4gnr4d51i3s"))))
    (build-system go-build-system)
    (arguments
     `(#:import-path "github.com/tidwall/pretty"))
    (home-page "https://github.com/tidwall/pretty")
    (synopsis "Efficient JSON beautifier and compactor for Go")
    (description "Pretty is a Go package that provides fast methods for
formatting JSON for human readability, or to compact JSON for smaller
payloads.")
    (license license:expat)))

(define-public go-github-com-zyedidia-poller
  (package
    (name "go-github-com-zyedidia-poller")
    (version "1.0.1")
    (source
      (origin
        (method git-fetch)
        (uri (git-reference
               (url "https://github.com/zyedidia/poller")
               (commit (string-append "v" version))))
        (file-name (git-file-name name version))
        (sha256
          (base32 "10cjrqfk1j0l55bdbpm7kv4mqc665pngc8avai0p9chq03y2654g"))))
    (build-system go-build-system)
    (arguments '(#:import-path "github.com/zyedidia/poller"))
    (home-page "https://github.com/zyedidia/poller")
    (synopsis "poller")
    (description
      "Package poller is a file-descriptor multiplexer.  It allows concurent Read and
Write operations from and to multiple file-descriptors without allocating one OS
thread for every blocked operation.  It operates similarly to Go's netpoller
(which multiplexes network connections) without requiring special support from
the Go runtime.  It can be used with tty devices, character devices, pipes,
FIFOs, and any file-descriptor that is poll-able (can be used with select(2),
epoll(7), etc.) In addition, package poller allows the user to set timeouts
(deadlines) for read and write operations, and also allows for safe cancelation
of blocked read and write operations; a Close from another go-routine safely
cancels ongoing (blocked) read and write operations.")
    (license license:bsd-2)))

(define-public go-maunium-net-go-tcell
  (package
    (name "go-maunium-net-go-tcell")
    (version "0.2.0")
    (source
      (origin
        (method git-fetch)
        (uri (git-reference
               (url "https://github.com/tulir/tcell")
               (commit (string-append "v" version))))
        (file-name (git-file-name name version))
        (sha256
          (base32 "0g7xdvk13wzz3pj2nzbj3sz6y4rki9n141nxy93lak4rn43ahm9z"))))
    (build-system go-build-system)
    (arguments '(#:import-path "maunium.net/go/tcell"))
    (propagated-inputs
      `(("go-golang-org-x-text" ,go-golang-org-x-text)
        ("go-golang-org-x-sys" ,go-golang-org-x-sys)
        ("go-github-com-zyedidia-poller" ,go-github-com-zyedidia-poller)
        ("go-github-com-mattn-go-runewidth" ,go-github-com-mattn-go-runewidth)
        ("go-golang-org-colorful" ,go-golang-org-colorful)
        ("go-github-com-gdamore-encoding" ,go-github-com-gdamore-encoding)))
    (home-page "https://maunium.net/go/tcell")
    (synopsis "")
    (description
      "Package tcell provides a lower-level, portable API for building programs that
interact with terminals or consoles.  It works with both common (and many
uncommon!) terminals or terminal emulators, and Windows console implementations.")
    (license license:asl2.0)))

(define-public go-github-com-tidwall-match
  (package
    (name "go-github-com-tidwall-match")
    (version "1.1.1")
    (source
      (origin
        (method git-fetch)
        (uri (git-reference
               (url "https://github.com/tidwall/match")
               (commit (string-append "v" version))))
        (file-name (git-file-name name version))
        (sha256
          (base32 "1n25md63xr5m66r6zc77n6fgcpv2ljrlk92ivp9hvp8xya22as9k"))))
    (build-system go-build-system)
    (arguments '(#:import-path "github.com/tidwall/match"))
    (home-page "https://github.com/tidwall/match")
    (synopsis "Simple string pattern matcher for Go")
    (description
"@code{go-github-com-tidwall-match} is a very simple pattern matcher where @code{*}
matches on any number of characters and @code{?} matches on any one character.")
    (license license:expat)))

(define-public go-github-com-tidwall-gjson
  (package
    (name "go-github-com-tidwall-gjson")
    (version "1.13.0")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/tidwall/gjson")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "019dq1wjvr46rmqzqxdd4p516nsysiaq3d1z713pc6q9jhz3lbh9"))))
    (build-system go-build-system)
    (inputs
     (list go-github-com-tidwall-match go-github-com-tidwall-pretty))
    (arguments `(#:import-path "github.com/tidwall/gjson"))
    (home-page "https://github.com/tidwall/gjson/")
    (synopsis "JSON parser for Go")
    (description "GJSON is a Go package that provides a fast and simple way to
get values from a JSON document.")
    (license license:expat)))

(define-public go-github-com-tidwall-sjson
  (package
   (name "go-github-com-tidwall-sjson")
   (version "1.2.4")
   (source (origin
            (method git-fetch)
            (uri (git-reference
                  (url "https://github.com/tidwall/sjson")
                  (commit (string-append "v" version))))
            (file-name (git-file-name name version))
            (sha256
             (base32
              "0p3x52gnznmyld6k9ii3qkmb09vh5sd7zycfm1pjn6mzidzrhvk3"))))
   (build-system go-build-system)
   (inputs
    (list go-github-com-tidwall-gjson
          go-github-com-tidwall-match
          go-github-com-tidwall-pretty))
   (arguments
    `(#:import-path "github.com/tidwall/sjson"))
   (home-page "https://github.com/tidwall/sjson")
   (synopsis "Set a json value quickly")
   (description
    "SJSON is a Go package that provides a very fast and simple way to
set a value in a json document.")
   (license license:expat)))

(define-public go-maunium-net-go-maulogger-v2
  (package
    (name "go-maunium-net-go-maulogger-v2")
    (version "2.3.2")
    (source
      (origin
        (method git-fetch)
        (uri (git-reference
               (url "https://github.com/tulir/maulogger")
               (commit (string-append "v" version))))
        (file-name (git-file-name name version))
        (sha256
          (base32 "1kxwx2fby58iws78dlb4cgbgwak35y5b9hswrlrv4gi0pbawwnhn"))))
    (build-system go-build-system)
    (arguments
      '(#:import-path
        "maunium.net/go/maulogger/v2"
        #:unpack-path
        "maunium.net/go/maulogger/v2"))
    (home-page "https://maunium.net/go/maulogger/v2")
    (synopsis "maulogger")
    (description "This package provides a logger in Go.")
    (license license:mpl2.0)))

(define-public go-maunium-net-go-mauview
  (package
    (name "go-maunium-net-go-mauview")
    (version "0.1.4-0.20211207121125-01ffaf935896")
    (source
      (origin
        (method git-fetch)
        (uri (git-reference
               (url "https://github.com/tulir/mauview")
               (commit (go-version->git-ref version))))
        (file-name (git-file-name name version))
        (sha256
          (base32 "0fjjabvjm0lqyz2gjxh4fplj3fmibkspgk6vm1pq6krlbdmjn855"))))
    (build-system go-build-system)
    (arguments '(#:import-path "maunium.net/go/mauview"))
    (propagated-inputs
      `(("go-maunium-net-go-tcell" ,go-maunium-net-go-tcell)
        ("go-github-com-zyedidia-clipboard" ,go-github-com-zyedidia-clipboard)
        ("go-github-com-rivo-uniseg" ,go-github-com-rivo-uniseg)
        ("go-github-com-mattn-go-runewidth" ,go-github-com-mattn-go-runewidth)
        ("go-github-com-lucasb-eyer-go-colorful"
         ,go-github-com-lucasb-eyer-go-colorful)))
    (home-page "https://maunium.net/go/mauview")
    (synopsis "mauview")
    (description "From")
    (license license:mpl2.0)))

(define-public go-maunium-net-go-mautrix
  (package
    (name "go-maunium-net-go-mautrix")
    (version "0.10.12")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/mautrix/go")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "1lin39p95ipjn4ww2pjglmd8v3myqgj08937ch5k6pbsvsqxbi7g"))))
    (build-system go-build-system)
    (propagated-inputs
      (list go-golang-org-x-crypto
            go-golang-org-x-net
            go-github-com-gorilla-websocket
            go-github-com-mattn-go-sqlite3-for-gomuks
            go-github-com-gorilla-mux
            go-github-com-russross-blackfriday-for-gomuks
            go-github-com-stretchr-testify
            go-github-com-tidwall-gjson
            go-github-com-tidwall-sjson
            go-gopkg-in-yaml-v2
            go-github-com-tulir-maulogger))
            ;;go-github-com-davecgh-go-spew
            ;;go-github-com-pmezard-go-difflib
            ;;go-github-com-tidwall-pretty
            ;;go-github-com-tidwall-match
    (arguments
     `(#:import-path "maunium.net/go/mautrix"))
    (home-page "https://maunium.net/go/mautrix/")
    (synopsis "Golang Matrix framework")
    (description
"@code{go-maunium-net-go-mautrix} is a Golang Matrix framework.")
    (license license:mpl2.0)))

(define-public go-mvdan-cc-xurls
  (package
    (name "go-mvdan-cc-xurls")
    (version "2.4.0")
    (source
      (origin
        (method git-fetch)
        (uri (git-reference
               (url "https://github.com/mvdan/xurls")
               (commit (string-append "v" version))))
        (file-name (git-file-name name version))
        (sha256
          (base32 "0b040nbk1vwlk1qljavh8w8fn2r243q700n6gr8j2asmnz0xq84p"))))
    (build-system go-build-system)
    (arguments
      '(#:import-path "mvdan.cc/xurls/v2" #:unpack-path "mvdan.cc/xurls/v2"))
    (propagated-inputs
      (list go-golang-org-x-sync go-github-com-rogpeppe-go-internal))
    (home-page "https://mvdan.cc/xurls/v2")
    (synopsis "xurls")
    (description
      "Package xurls extracts urls from plain text using regular expressions.")
    (license license:bsd-3)))

(define-public go-github-com-delthas-tcell
  (let ((commit "8fc0c2be8f7d03abf14267e593bd2d104d4538b6")
        (revision "0"))
    (package
      (name "go-github-com-delthas-tcell")
      (version "v2.4.1-0.20220223131437-2362f49a2b6c")
      (source
        (origin
          (method git-fetch)
          (uri (git-reference
                 (url "https://github.com/delthas/tcell")
                 (commit (go-version->git-ref version))))
          (file-name (git-file-name name version))
          (sha256
            (base32 "04mai0gicllhjqv7p0i29cdf9myzl8q5h672bdhmid7lv3x1k32f"))))
      (build-system go-build-system)
      (arguments
        '(#:import-path "github.com/gdamore/tcell/v2"))
      (propagated-inputs
        (list go-github-com-gdamore-encoding
              go-github-com-lucasb-eyer-go-colorful
              go-github-com-mattn-go-runewidth
              go-golang-org-x-sys
              go-golang-org-x-term
              go-golang-org-x-text))
      (home-page "https://github.com/delthas/tcell")
      (synopsis "Provide a cell-based view for text terminals")
      (description "This package includes a full parser and expander for terminfo
capability strings to avoid hard-coding escape strings for formatting.  It favors
portability, and includes support for all POSIX systems.")
      (license license:asl2.0))))

(define-public go-github-com-axgle-mahonia
  (package
    (name "go-github-com-axgle-mahonia")
    (version "0.0.0-20180208002826-3358181d7394")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/axgle/mahonia")
                    (commit (go-version->git-ref version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "0b8wsrxmv8a0cqbnsg55lpf29pxy2zw8azvgh3ck664lqpcfybhq"))))
    (build-system go-build-system)
    (arguments
     (list #:import-path "github.com/axgle/mahonia"))
    (home-page "https://github.com/axgle/mahonia")
    (synopsis "Character set convertion for Go")
    (description "This package provides character set convertion as
a Go library.")
    (license license:bsd-3)))

(define-public go-github-com-slymarbo-rss
  (package
    (name "go-github-com-slymarbo-rss")
    (version "1.0.3")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/SlyMarbo/rss")
                    (commit (string-append "v" version))))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "1pg4kp9660h1pp0m98hwsdsmphj3230bk4ml0y8gmmrzlrf30dk9"))))
    (build-system go-build-system)
    (arguments
     (list #:tests? #f ;TODO: fix
           #:import-path "github.com/SlyMarbo/rss"))
    (propagated-inputs (list go-github-com-axgle-mahonia))
    (home-page "https://github.com/SlyMarbo/rss")
    (synopsis "RSS library for Go")
    (description
     "This package provides a small library that simplifies parsing RSS
and Atom feeds in Go.")
    (license license:bsd-3)))
